package com.mindskip.xzs.controller.admin;
//用于管理教育相关的功能，包括学科和批次的管理。提供了多种接口实现对学科和批次的增删改查操作。
//前端作用
//1. **学科管理接口**：
//    - **获取所有学科列表** (`/api/admin/education/subject/list`)：
//      - 前端调用此接口以获取所有学科的列表，通常用于显示在学科管理页面中。
//    - **获取学科分页列表** (`/api/admin/education/subject/page`)：
//      - 前端根据分页请求参数调用此接口获取学科的分页列表，用于实现分页显示学科数据。
//    - **删除学科** (`/api/admin/education/subject/delete/{id}`)：
//      - 前端调用此接口删除指定 ID 的学科，用户在学科管理页面中选择删除某个学科时触发此操作。
//
//2. **批次管理接口**：
//    - **新建或修改批次** (`/api/admin/education/batch/edit`)：
//      - 前端调用此接口提交新建或修改批次的请求，包括批次的基本信息和关联的用户及任务。
//    - **获取批次数据列表** (`/api/admin/education/batchList`)：
//      - 前端调用此接口获取所有批次的列表，通常用于显示在批次管理页面中。
//    - **获取批次分页列表** (`/api/admin/education/batch/page`)：
//      - 前端根据分页请求参数调用此接口获取批次的分页列表，用于实现分页显示批次数据。
//    - **删除批次** (`/api/admin/education/batch/delete/{id}`)：
//      - 前端调用此接口删除指定 ID 的批次，用户在批次管理页面中选择删除某个批次时触发此操作。
//    - **获取批次详细信息** (`/api/admin/education/batch/select/{id}`)：
//      - 前端调用此接口获取指定 ID 批次的详细信息，用于在批次编辑页面中显示当前批次的信息以便修改。
//后端作用
//1. **学科管理**：
//    - **`list()`**：
//      - 调用 `subjectService.allSubject()` 获取所有学科列表并返回。
//    - **`pageList()`**：
//      - 调用 `subjectService.page(model)` 获取分页的学科列表，并将其映射为 `SubjectResponseVM` 类型的对象，最后返回分页信息。
//    - **`delete()`**：
//      - 标记指定 ID 的学科为已删除，调用 `subjectService.updateByIdFilter(subject)` 更新学科状态。
//
//2. **批次管理**：
//    - **`edit()`**：
//      - 新建批次或修改批次：
//        - 对于新建批次，生成新的批次 ID，创建批次对象并保存批次信息、批次用户信息和批次任务信息。
//        - 对于修改批次，更新批次信息，删除旧的批次用户信息并保存新的批次用户信息，更新批次任务信息。
//    - **`batchList()`**：
//      - 调用 `batchServer.list()` 获取所有批次列表并返回。
//    - **`batchPage()`**：
//      - 根据分页请求参数调用 `batchServer.getBatchPage(model)` 获取分页的批次列表并返回。
//    - **`batchPage(@PathVariable String id)`**：
//      - 删除指定 ID 的批次，包括批次信息、批次用户信息和批次任务信息。
//    - **`select()`**：
//      - 获取指定 ID 的批次的详细信息，包括批次基本信息、关联的用户 ID 列表和任务 ID，返回批次编辑响应模型。
import com.mindskip.xzs.base.BaseApiController;
import com.mindskip.xzs.base.RestResponse;
import com.mindskip.xzs.domain.*;
import com.mindskip.xzs.service.BatchServer;
import com.mindskip.xzs.service.BatchTaskServer;
import com.mindskip.xzs.service.BatchUserServer;
import com.mindskip.xzs.service.SubjectService;
import com.mindskip.xzs.utility.PageInfoHelper;
import com.mindskip.xzs.utility.SnowFlake;
import com.mindskip.xzs.viewmodel.admin.education.SubjectPageRequestVM;
import com.mindskip.xzs.viewmodel.admin.education.SubjectResponseVM;
import com.github.pagehelper.PageInfo;
import com.mindskip.xzs.viewmodel.batch.BatchEditRequestVM;
import com.mindskip.xzs.viewmodel.batch.BatchEditResponseVM;
import com.mindskip.xzs.viewmodel.batch.BatchPageRequestVm;
import com.mindskip.xzs.viewmodel.batch.BatchPageResponseVM;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.validation.Valid;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
 * 教育管理控制器，提供了对学科和批次的管理功能
 */
@RestController("AdminEducationController")
@RequestMapping(value = "/api/admin/education")
public class EducationController extends BaseApiController {

    // 学科服务
    private final SubjectService subjectService;
    // 批次服务
    private final BatchServer batchServer;
    // 使用构造器注入学科服务和批次服务
    @Autowired
    public EducationController(SubjectService subjectService, BatchServer batchServer) {
        this.subjectService = subjectService;
        this.batchServer = batchServer;
    }
    // 使用@Resource注入批次用户服务和批次任务服务
    @Resource
    private BatchUserServer batchUserServer;
    @Resource
    private BatchTaskServer batchTaskServer;
    /**
     * 获取所有学科列表
     * @return 学科列表
     */
    @RequestMapping(value = "/subject/list", method = RequestMethod.POST)
    public RestResponse<List<Subject>> list() {
        List<Subject> subjects = subjectService.allSubject();
        return RestResponse.ok(subjects);
    }
    /**
     * 获取学科分页列表
     * @param model 分页请求模型
     * @return 学科分页列表
     */

    @RequestMapping(value = "/subject/page", method = RequestMethod.POST)
    public RestResponse<PageInfo<SubjectResponseVM>> pageList(@RequestBody SubjectPageRequestVM model) {
        PageInfo<Subject> pageInfo = subjectService.page(model);
        PageInfo<SubjectResponseVM> page = PageInfoHelper.copyMap(pageInfo, e -> modelMapper.map(e, SubjectResponseVM.class));
        return RestResponse.ok(page);
    }

    /**
    * @Description: 新建或者修改批次
    */
    @RequestMapping(value = "/batch/edit", method = RequestMethod.POST)
    public RestResponse edit(@RequestBody @Valid BatchEditRequestVM model) {
//        System.out.println(model);
        SnowFlake snowFlake=new SnowFlake(0L,0L);
        if(model.getId() == ""){//新建批次
            String batchId =snowFlake.generateNextId();
            Batch batch =new Batch();
            batch.setId(batchId);
            batch.setName(model.getName());
            List<BatchUser> batchUsers=new ArrayList<>();
            for(Integer id: model.getStudentArray()) {
                BatchUser batchUser = new BatchUser();
                batchUser.setUserId(id);
                batchUsers.add(batchUser);
            }
            BatchTask batchTask=new BatchTask();
            batchTask.setTaskId(model.getTaskId());
            try {
                batchServer.save(batch);
                batchUserServer.saveBatch(batchUsers);
                batchTaskServer.save(batchTask);
                return RestResponse.ok();
            }catch (Exception e){
                System.out.println(e);
                return RestResponse.fail(-1,"操作失败");
            }

        }else {// 修改批次
            try {
                Batch batch= batchServer.getById(model.getId());
                batch.setName(model.getName());
                        List<BatchUser> batchUserList= batchUserServer.getBatchUserByBatchId(model.getId());
                List<Integer> batchUserIds =new LinkedList<>();
                for(BatchUser batchUser :batchUserList){
                        batchUserIds.add(batchUser.getId());
                }
                List<BatchUser> batchUsers =new LinkedList<>();
                for (Integer studentId:model.getStudentArray()){
                    BatchUser batchUser=new BatchUser();
                    batchUser.setBatchId(model.getId());
                    batchUser.setUserId(studentId);
                    batchUsers.add(batchUser);
                }
                BatchTask oldBatchTask= batchTaskServer.getBatchTaskByBatchId(model.getId());
                oldBatchTask.setTaskId(model.getTaskId());
                batchServer.updateById(batch);
                batchUserServer.deletedByBatchId(batchUserIds);
                batchUserServer.saveBatch(batchUsers);
                batchTaskServer.updateById(oldBatchTask);
                return RestResponse.ok();
            }catch (Exception e){
                System.out.println(e);
                return RestResponse.fail(-1,"操作失败");
            }

        }
    }
    /**获取批次数据列表*/
    @RequestMapping (value = "/batchList", method = RequestMethod.GET)
    public  RestResponse<List<Batch>> batchList(){
        return RestResponse.ok(batchServer.list());
    }
    /**获取批次分页*/
    @RequestMapping(value = "/batch/page",method =RequestMethod.POST)
    public  RestResponse<BatchPageResponseVM> batchPage(@RequestBody @Valid BatchPageRequestVm model){
            return  RestResponse.ok(batchServer.getBatchPage(model));
    }
    /**删除批次*/
    @RequestMapping(value = "/batch/delete/{id}",method =RequestMethod.POST)
    public  RestResponse batchPage(@PathVariable String id){
        try {
            List<BatchUser> batchUserList =batchUserServer.getBatchUserByBatchId(id);
            List<Integer> batchUserIds =new LinkedList<>();
            for(BatchUser batchUser:batchUserList){
                    batchUserIds.add(batchUser.getId());
            }
            batchServer.removeById(id);
            batchUserServer.deletedByBatchId(batchUserIds);
            batchTaskServer.removeById(batchTaskServer.getBatchTaskByBatchId(id).getId());
            return  RestResponse.ok();
        }catch (Exception e){
            System.out.println(e);
            return RestResponse.fail(-1,"操作失败");
        }
    }

    /**获取批次详细信息*/
    @RequestMapping(value = "/batch/select/{id}", method = RequestMethod.POST)
    public RestResponse<BatchEditResponseVM> select(@PathVariable String id) {
        try {
            BatchEditResponseVM batchEditResponseVM = new BatchEditResponseVM();
            Batch batch = batchServer.getById(id);
            List<Integer> studentIds = new LinkedList<>();
            for (BatchUser batchUser : batchUserServer.getBatchUserByBatchId(id)) {
                studentIds.add(batchUser.getUserId());
            }
            batchEditResponseVM.setId(id);
            batchEditResponseVM.setName(batch.getName());
            batchEditResponseVM.setStudentArray(studentIds);
            batchEditResponseVM.setTaskId(batchTaskServer.getBatchTaskByBatchId(id).getTaskId());
            return RestResponse.ok(batchEditResponseVM);
        }catch (Exception e){
            return RestResponse.fail(-1,"操做失败");
        }
    }
    /**删除学科*/
    @RequestMapping(value = "/subject/delete/{id}", method = RequestMethod.POST)
    public RestResponse delete(@PathVariable Integer id) {
        Subject subject = subjectService.selectById(id);
        subject.setDeleted(true);
        subjectService.updateByIdFilter(subject);
        return RestResponse.ok();
    }
}
